/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package jogo;

import java.util.Enumeration;
import java.util.Vector;
import util.Constantes;

/**
 *
 * @author Thiago Nascimento e Pablo Viana
 */
public class Jogador {

    private String nome;
    private Vector pecas;
    private boolean ehMaquina;

    // CONSTRUTORES ////////////////////////////////////////////////////////////
    public Jogador() {
    }

    public Jogador(String nome) {
        this(nome, new Vector(10), false);
    }

    public Jogador(String nome, boolean ehMaquina) {
        this(nome, new Vector(10), ehMaquina);
    }

    public Jogador(String nome, Vector pecas, boolean ehMaquina) {
        this.nome = nome;
        this.pecas = pecas;
        this.ehMaquina = ehMaquina;
    }

    // GETS AND SETS ///////////////////////////////////////////////////////////
    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public Vector getPecas() {
        return pecas;
    }

    public void setPecas(Vector pecas) {
        this.pecas = pecas;
    }

    public boolean ehMaquina() {
        return ehMaquina;
    }

    public void setEhMaquina(boolean ehMaquina) {
        this.ehMaquina = ehMaquina;
    }

    // METODOS OVERRIDE ////////////////////////////////////////////////////////    
    public int hashCode() {
        return this.getNome().hashCode();
    }

    public boolean equals(Object o) {
        if (o instanceof Jogador) {
            Jogador j = (Jogador) o;
            return this.equals(j);
        }
        return false;
    }

    // METODOS /////////////////////////////////////////////////////////////////
    public boolean equals(Jogador j) {
        if (j != null) {
            return this.getNome().equals(j.getNome());
        }
        return false;
    }

    public boolean temPeca(Peca peca) {
        return this.pecas.contains(peca);
    }

    // Remove a peca do jogador se ele a possuir, retorna true se existia essa peca false se nao.
    public boolean jogarPeca(Peca peca) {
        return this.pecas.removeElement(peca);
    }

    public Peca podeJogar(int cabecaUm, int cabecaDois) {
        for (Enumeration e = this.pecas.elements(); e.hasMoreElements();) {
            Peca peca = (Peca) e.nextElement();
            if (peca.encaixa(cabecaUm) || peca.encaixa(cabecaDois)) {
                return peca;
            }
        }
        return null;
    }

      public Jogada getJogadaDaMaquina(int cabecaDireita, int cabecaEsquerda, 
            int dificuldade, Vector jogadas) {
        Jogada jogada = null;
        Peca peca =null;       
        Peca ultimaJogada = null;
        switch(dificuldade){
            case Constantes.FACIL:
                //Temporario para jogar alguma peça
                peca = this.podeJogar(cabecaDireita, cabecaEsquerda);
                if (peca != null && this.temPeca(peca)) {
                    if(cabecaDireita == peca.getValor1() || 
                            cabecaDireita == peca.getValor2()){
                        jogada = new Jogada(this, peca, Constantes.LADO_DIREITO);
                    }else{
                        jogada = new Jogada(this, peca, Constantes.LADO_ESQUERDO);
                    }
                }else{
                    jogada = new Jogada();
                }
                break;
            case Constantes.NORMAL:
                //Verificar se tem carroça
                peca = new Peca(cabecaDireita, cabecaDireita);
                if (this.temPeca(peca)) {
                    return new Jogada(this, peca, Constantes.LADO_DIREITO);
                }
                peca = new Peca(cabecaEsquerda, cabecaEsquerda);
                if (this.temPeca(peca)) {
                    return new Jogada(this, peca, Constantes.LADO_ESQUERDO);
                }
                for(int i=jogadas.size()-1; i >=0;i--){
                    ultimaJogada = ((Jogada)jogadas.elementAt(i)).getPeca();
                    if(ultimaJogada!=null){
                        break;
                    }
                }
                
                if(ultimaJogada.encaixa(cabecaDireita)){
                   Peca p = this.podeJogar(cabecaDireita, cabecaDireita);
                   if (p != null && this.temPeca(p)) {
                       jogada = new Jogada(this, p, Constantes.LADO_DIREITO);
                   }else{
                       p = this.podeJogar(cabecaEsquerda, cabecaEsquerda);
                       if (p != null && this.temPeca(p)) {
                           jogada = new Jogada(this, p, Constantes.LADO_ESQUERDO);
                       }else{
                        jogada = new Jogada();
                       }
                   }
                }else{
                   Peca p = this.podeJogar(cabecaEsquerda, cabecaEsquerda);
                   if (p != null && this.temPeca(p)) {
                       jogada = new Jogada(this, p, Constantes.LADO_ESQUERDO);
                   }else{
                        p = this.podeJogar(cabecaDireita, cabecaDireita);
                       if (p != null && this.temPeca(p)) {
                           jogada = new Jogada(this, p, Constantes.LADO_DIREITO);
                       }else{
                        jogada = new Jogada();
                       }
                   }
                }
                break;
            case Constantes.DIFICIL:
              for(int i=jogadas.size()-1; i >=0;i--){
                    ultimaJogada = ((Jogada)jogadas.elementAt(i)).getPeca();
                    if(ultimaJogada!=null){
                        break;
                    }
                }
                Vector possiveisJogadasDireito = new Vector();
                Vector possiveisJogadasEsquerdo = new Vector();
                Peca aux = new Peca(cabecaDireita, cabecaEsquerda);
                for(int i =0; i <pecas.size();i++){
                    Peca p = (Peca)pecas.elementAt(i);
                    if(p.getValor1() == cabecaDireita || 
                        p.getValor2() == cabecaDireita){
                        possiveisJogadasDireito.addElement(new Jogada(this, p, Constantes.LADO_DIREITO));
                    } 
                    if(p.getValor1() == cabecaEsquerda || 
                        p.getValor2() == cabecaEsquerda){
                        possiveisJogadasEsquerdo.addElement(new Jogada(this, p, Constantes.LADO_ESQUERDO));
                    } 
                }
                if(ultimaJogada.encaixa(cabecaDireita)){
                     if(this.temPeca(aux)){
                         jogada= new Jogada(this, aux, Constantes.LADO_DIREITO);
                     }else{
                        if(possiveisJogadasDireito.size()!=0){
                             jogada=(Jogada)possiveisJogadasDireito.elementAt(0);
                        }else if(possiveisJogadasEsquerdo.size()!=0){
                             jogada= (Jogada)possiveisJogadasEsquerdo.elementAt(0);
                        }else{
                            jogada= new Jogada();
                        }
                     }
                    
                }else{
                    if(this.temPeca(aux)){
                          jogada= new Jogada(this, aux, Constantes.LADO_DIREITO);
                     }else{
                        if(possiveisJogadasEsquerdo.size()!=0){
                             jogada= (Jogada)possiveisJogadasEsquerdo.elementAt(0);
                        }else if(possiveisJogadasDireito.size()!=0){
                             jogada= (Jogada)possiveisJogadasDireito.elementAt(0);
                        }else{
                             jogada= new Jogada();
                        }
                     }
                }
                
                break;
        }
        
        return jogada;
    }
    
}
